Aminet 51/Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso/Aminet/dev/c/minigl.lha/MiniGL/src/vertexarray.c

C/C++ Source or Header | 2002-07-03 | 76.9 KB | 3,419 lines

/*
 * $Id: vertexarray.c,v 1.3 2001/02/05 16:56:03 tfrieden Exp $
 *
 * $Date: 2001/02/05 16:56:03 $
 * $Revision: 1.3 $
 *
 * (C) 1999 by Hyperion
 * All rights reserved
 *
 * This file is part of the MiniGL library project
 * See the file Licence.txt for more details
 *
 */

/*
** glDrawArrays pipeline by Christian 'SuRgEoN' Michael
** Thanks to Olivier Fabre for bug-hunting
*/

/*
** revised 07-04-02:
**
** In some cases A_DrawTriangles didn't use the correct
** start position during backface-culling
**
** Support for GL_EXT_compiled_vertex_array was added.
**
** When Clip_Volume_Bypass is GL_FALSE, it will wrap
** to GLDrawElements (at the very beginning of GLDrawArrays,
** which is ofcourse not an optimal solution.
** Anyways, the use if glDrawArrays is probably rare in case
** of compiled arrays, but it should be supported.
** One possible solution to this is to make the default
** W3D_VertexPointer point to the W3D_Vertex struct inside
** the vertexbuffer like for elements, but it would probably
** lower the general performance of glDrawArrays.
*/


#include "sysinc.h"
#include "vertexarray.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


/*

NOTE:
    Transformation and clipping pipeline can be turned on/off with glDisable/glEnable(MGL_ARRAY_TRANSFORMATIONS) before the pointers are set.

The MGL_FLATFAN will work regardless of pipeline state.

Tricky stuff:

Problem 1: We don't want to copy texcoords unless we really have to (clipping) and we don't want to write the w-coords to application-arrays since a texcoordpointer is allowed to have a stride of 2.

    Current solution:
    We allocate some memory exclusively for the w-coords
    in order to cope with any texcoordstride.
    The relative w-coord buffer offset is calculated
    whenever texcoordpointer is set.

Problem 2: Clipping events are expensive because texcoords and colors currently need to be converted and copied to the vertexbuffer.

    Solution: ?? Currently, a sort of guardband is used
             in order to avoid clipping in most cases.


TODO:

- Implement remaining GL primitives.
- Implement MGL_UBYTE_ARGB color-format (Voodoo3 native)
- Write pointer-wrapper for glInterleavedArrays and proper
  optimized conversion-routines for clipping.
- Implement multitexturing (virtual TMU for now).

*/



//NYI:

void A_DrawPoints        (GLcontext context, const int first, const int count);
void A_DrawLines         (GLcontext context, const int first, const int count);
void A_DrawLineStrip     (GLcontext context, const int first, const int count);
void A_DrawLineLoop      (GLcontext context, const int first, const int count);

void A_DrawQuads         (GLcontext context, const int first, const int count);
void A_DrawQuadStrip      (GLcontext context, const int first, const int count);

//implemented:

void A_DrawTriFan       (GLcontext context, const int first, const int count);
void A_DrawTriStrip       (GLcontext context, const int first, const int count);
void A_DrawTriangles     (GLcontext context, const int first, const int count);
void A_DrawPolygon       (GLcontext context, const int first, const int count);
void A_DrawFlatFan       (GLcontext context, const int first, const int count);


extern void TMA_Start(LockTimeHandle *handle);
extern GLboolean TMA_Check(LockTimeHandle *handle);
extern void fog_Set(GLcontext context);
static INLINE void PreDraw(GLcontext context);
static INLINE void PostDraw(GLcontext context);


static GLboolean Reset_W3D_VertexPointer = GL_TRUE;

int A_TransformArray (GLcontext context, const int first, const int size);

void A_ToScreenArray(GLcontext context, const int first, const int size);


extern void m_CombineMatrices(GLcontext context);


//Culling:

GLboolean DecideFrontface(GLcontext context, const MGLVertex *a, const MGLVertex *b, const MGLVertex *c, int sign);


//Clipping (convert color and texcoords to vertexbuffer)

void Convert_F_RGB(GLcontext context, int i);
void Convert_F_RGBA(GLcontext context, int i);
void Convert_UB_RGB(GLcontext context, int i);
void Convert_UB_RGBA(GLcontext context, int i);
void Convert_UB_BGR(GLcontext context, int i);
void Convert_UB_BGRA(GLcontext context, int i);
void Convert_UB_ARGB(GLcontext context, int i);

//pointer to color/texcoord conversion routine for clipping events:

Convfn Convert = (Convfn)Convert_F_RGBA;

extern void AE_ClipPoly(GLcontext context, PolyBuffer *out, int clipstart, ULONG or_codes);



//stuff for compiled arrays:  added 07-04-2002

extern GLboolean Clip_Volume_Bypass;

#define MAX_ELEMENTS 16384 //should be enough

static UWORD e_wrap[MAX_ELEMENTS]; //should be enough

//called from MGLInit:

void Init_ArrayToElements_Warpper(void)
{
    int i;

    for (i=0; i<MAX_ELEMENTS; i++)
        e_wrap[i] = i;
}

//called at the very beginning of GLDrawArrays in case clipping is needed with compiled arrays:

extern void GLDrawElements(GLcontext context, GLenum mode, const GLsizei count, GLenum type, const GLvoid *indices);

// end of compiled arrays support


int A_TransformArray (GLcontext context, const int first, const int size)
{
   int i;
   ULONG and_code, or_code, guard_band;

        #define OF_11 0
        #define OF_12 4
        #define OF_13 8
        #define OF_14 12

        #define OF_21 1
        #define OF_22 5
        #define OF_23 9
        #define OF_24 13

        #define OF_31 2
        #define OF_32 6
        #define OF_33 10
        #define OF_34 14

        #define OF_41 3
        #define OF_42 7
        #define OF_43 11
        #define OF_44 15

        #define a(x) (context->CombinedMatrix.v[OF_##x])

   if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
    static int m[16];
    int tx,ty,tz,tw;
    int x,y,z;
      int *vp;
    ULONG local_outcode;
    UBYTE *vpointer;
    MGLVertex *v;
    int stride;

      #define CLIP_EPS ((int)((1e-7)*32768.f))
     #define b(x) (m[OF_##x])

      if(context->CombinedValid == GL_FALSE)
    {
    const float float2fix = 32768.f;

            m_CombineMatrices(context);

        b(11)=(int)(a(11)*float2fix);
        b(12)=(int)(a(12)*float2fix);
        b(13)=(int)(a(13)*float2fix);
        b(14)=(int)(a(14)*float2fix);
        b(21)=(int)(a(21)*float2fix);
        b(22)=(int)(a(22)*float2fix);
        b(23)=(int)(a(23)*float2fix);
        b(24)=(int)(a(24)*float2fix);
        b(31)=(int)(a(31)*float2fix);
        b(32)=(int)(a(32)*float2fix);
        b(33)=(int)(a(33)*float2fix);
        b(34)=(int)(a(34)*float2fix);
        b(41)=(int)(a(41)*float2fix);
        b(42)=(int)(a(42)*float2fix);
        b(43)=(int)(a(43)*float2fix);
        b(44)=(int)(a(44)*float2fix);
    }

     stride = context->ArrayPointer.vertexstride;
     vpointer = (context->ArrayPointer.verts + first*stride);

     and_code = 0xff;
     or_code = 0;

     v = &(context->VertexBuffer[first]);

     i = size;
     do
     {

      vp = (int *)vpointer;

      x = vp[0];
      y = vp[1];
      z = vp[2];

//pipelined transformations

       tx  = x*b(11);
       ty  = x*b(21);
       tz  = x*b(31);
       tw  = x*b(41);

    tx += y*b(12);
    ty += y*b(22);
    tz += y*b(32);
    tw += y*b(42);

    tx += z*b(13);
    ty += z*b(23);
    tz += z*b(33);
    tw += z*b(43);

    tx += b(14);
    ty += b(24);
    tz += b(34);
    tw += b(44);

    local_outcode = 0;

        if (tw < CLIP_EPS )
      {
                local_outcode |= MGL_CLIP_NEGW;
      }
        if (-tw > tx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (tx > tw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-tw > ty)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (ty > tw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-tw > tz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (tz > tw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

    v->bx = (float)tx;
    v->by = (float)ty;
    v->bz = (float)tz;
    v->bw = (float)tw;

      v->outcode = local_outcode;
      and_code &= local_outcode;
      or_code  |= local_outcode;

     v++; vpointer += stride;

     } while (--i);

    #undef b
    #undef CLIP_EPS
   }
   else
   {
      float a11,a12,a13,a14;
      float a21,a22,a23,a24;
      float a31,a32,a33,a34;
      float a41,a42,a43,a44;
      float *vp;
      float cw;
    float x,y,z;
    ULONG local_outcode;
    UBYTE *vpointer;
    MGLVertex *v;
    int stride;

      #define CLIP_EPS (1e-7)

     if(context->CombinedValid == GL_FALSE)
            m_CombineMatrices(context);

     a11=a(11); a12=a(12); a13=a(13); a14=a(14);
     a21=a(21); a22=a(22); a23=a(23); a24=a(24);
     a31=a(31); a32=a(32); a33=a(33); a34=a(34);
     a41=a(41); a42=a(42); a43=a(43); a44=a(44);

     stride = context->ArrayPointer.vertexstride;
     vpointer = (context->ArrayPointer.verts + first*stride);

     v = &(context->VertexBuffer[first]);

     i = size;

     do
     {
        vp = (float *)vpointer;

        x = vp[0];
        y = vp[1];
        z = vp[2];

        v->bx = a11*x + a12*y + a13*z + a14;
        v->by = a21*x + a22*y + a23*z + a24;
        v->bz = a31*x + a32*y + a33*z + a34;
        v->bw = a41*x + a42*y + a43*z + a44;

     v++; vpointer += stride;

     } while (--i);


     //prepare culling;

     and_code = 0xff;
     or_code = 0;

     v = &context->VertexBuffer[first];

     i = size;

     do
     {
        cw = v->bw;
        local_outcode = 0;

        if (cw < CLIP_EPS )
      {
                local_outcode |= MGL_CLIP_NEGW;
      }
        if (-cw > v->bx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (v->bx > cw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-cw > v->by)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (v->by > cw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-cw > v->bz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (v->bz > cw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

        and_code &= local_outcode;
        or_code  |= local_outcode;
        v->outcode = local_outcode;

     v++;
     } while (--i);

    #undef CLIP_EPS
   }

   #undef a

   if (and_code)
    return -1;

   if(or_code == 0 || (or_code & context->ClipFlags))
   {
     return (int)or_code;
   }
   else
   {
    float gcw;
    ULONG guard_code;
    MGLVertex *v;

    i = size;
    guard_band = 0;

    v = &context->VertexBuffer[first];

    do
    {

      if(v->outcode)
      {
       gcw = v->bw * 2.0;
      guard_code = 0;

        if (-gcw > v->bx)
        {
          guard_code |= MGL_CLIP_LEFT;
        }
        else if (v->bx > gcw)
        {
          guard_code |= MGL_CLIP_RIGHT;
        }

        if (-gcw > v->by)
        {
          guard_code |= MGL_CLIP_BOTTOM;
        }
        else if (v->by > gcw)
        {
          guard_code |= MGL_CLIP_TOP;
        }

      guard_band |= guard_code;
        }

    v++;
    } while (--i && guard_band == 0);

   return (int)guard_band;
   }
}


void A_ToScreenArray(GLcontext context, const int first, const int size)
{
   int i, stride;
   float x,y,z,w;

   UBYTE *pointer;
   float *wa;
   float az;

   if(context->ZOffset_State == GL_TRUE)
   {
       az = context->az + context->ZOffset;
   }
   else
   {
    az = context->az;
   }


   if(!(context->ClientState & GLCS_TEXTURE))
   {
       MGLVertex *v = &context->VertexBuffer[first];
      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

      v++;

      } while (--i);
   }
   else if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
       MGLVertex *v = &context->VertexBuffer[first];
       stride = context->ArrayPointer.texcoordstride;
       pointer = (UBYTE*)context->WBuffer + first * stride;

      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

         w *= 32768.f;

         wa = (float*)pointer;
         *wa = w;

      v++;
      pointer += stride;

      } while (--i);
   }
   else
   {
       MGLVertex *v = &context->VertexBuffer[first];
       stride = context->ArrayPointer.texcoordstride;
       pointer = (UBYTE*)context->WBuffer + first * stride;

      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

         wa = (float*)pointer;
         *wa = w;

      v++;
      pointer += stride;
      } while (--i);
   }
}



//fix to float conversion

INLINE void ConvertFixverts(GLcontext context, const int first, const int count)
{
    const float f = 1.0/32768.f;
    MGLVertex *v = &context->VertexBuffer[first];
    int i = count;

    do
    {
        v->bx = v->bx * f;
        v->by = v->by * f;
        v->bz = v->bz * f;
        v->bw = v->bw * f;

    v++;
    } while (--i);
}


// special case color-copy / texcoord-conversion routines


void Convert_F_RGB(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   float *col = (float*)(context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);;

      v->v.color.r = col[0];
      v->v.color.g = col[1];
      v->v.color.b = col[2];
    v->v.color.a = 1.0;
   }
}


void Convert_F_RGBA(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   float *col = (float*)(context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);;

      v->v.color.r = col[0];
      v->v.color.g = col[1];
      v->v.color.b = col[2];
      v->v.color.a = col[3];
   }
}


void Convert_UB_RGB(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   UBYTE *col = (context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);
   float f = 1.0/255.0;

      v->v.color.r = (float)col[0]*f;
      v->v.color.g = (float)col[1]*f;
      v->v.color.b = (float)col[2]*f;
      v->v.color.a = 1.0;
   }
}


void Convert_UB_RGBA(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   UBYTE *col = (context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);
   float f = 1.0/255.0;

      v->v.color.r = (float)col[0]*f;
      v->v.color.g = (float)col[1]*f;
      v->v.color.b = (float)col[2]*f;
      v->v.color.a = (float)col[3]*f;
   }
}


void Convert_UB_BGR(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   UBYTE *col = (context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);
   float f = 1.0/255.0;

      v->v.color.b = (float)col[0]*f;
      v->v.color.g = (float)col[1]*f;
      v->v.color.r = (float)col[2]*f;
      v->v.color.a = 1.0;
   }
}

void Convert_UB_BGRA(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   UBYTE *col = (context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);
   float f = 1.0/255.0;

      v->v.color.b = (float)col[0]*f;
      v->v.color.g = (float)col[1]*f;
      v->v.color.r = (float)col[2]*f;
      v->v.color.a = (float)col[3]*f;
   }
}

void Convert_UB_ARGB(GLcontext context, int i)
{
   MGLVertex *v;

   v = &context->VertexBuffer[i];

   if(context->ClientState & GLCS_TEXTURE)
   {
   float *tex = (float*)(context->ArrayPointer.texcoords + i * context->ArrayPointer.texcoordstride);

    v->v.u = tex[0] * (float)context->w3dTexBuffer[context->CurrentBinding]->texwidth;
    v->v.v = tex[1] * (float)context->w3dTexBuffer[context->CurrentBinding]->texheight;
   }

   if(context->ShadeModel == GL_SMOOTH)
   {
   UBYTE *col = (context->ArrayPointer.colors + i * context->ArrayPointer.colorstride);
   float f = 1.0/255.0;

      v->v.color.a = (float)col[0]*f;
      v->v.color.r = (float)col[1]*f;
      v->v.color.g = (float)col[2]*f;
      v->v.color.b = (float)col[3]*f;
   }
}


GLboolean DecideFrontface(GLcontext context, const MGLVertex *a, const MGLVertex *b, const MGLVertex *c, int sign)
{
        float a1,a2,b1,b2,r;
        float aw,bw,cw;

        aw = 1.0 / a->bw;
        bw = 1.0 / b->bw;
        cw = 1.0 / c->bw;

        a1 = a->bx*aw - b->bx*bw;
        a2 = a->by*aw - b->by*bw;
        b1 = c->bx*cw - b->bx*bw;
        b2 = c->by*cw - b->by*bw;

        r  = (a1*b2-a2*b1);

#if 0 //this test eliminates less than 1 in 1000 triangles

        #define EPSILON (1e-5)

        if (fabs(a1) < EPSILON && fabs(a2) < EPSILON)
        {
                return GL_FALSE;
        }
        if (fabs(b1) < EPSILON && fabs(b2) < EPSILON)
        {
                return GL_FALSE;
        }

#endif

        if((sign < 0 && r < 0.0) || (sign > 0 && r > 0.0))
                return GL_FALSE;
        else
                return GL_TRUE;
}


INLINE void A_ToScreen(GLcontext context, int vnum)
{
    UBYTE *pointer;
    float *wa;

    float w = 1.0/context->VertexBuffer[vnum].bw;

    context->VertexBuffer[vnum].bx = context->ax + context->VertexBuffer[vnum].bx * w * context->sx;
    context->VertexBuffer[vnum].by = context->ay - context->VertexBuffer[vnum].by * w * context->sy;
    context->VertexBuffer[vnum].bz = context->az + context->VertexBuffer[vnum].bz * w * context->sz;

    if (context->ZOffset_State == GL_TRUE)
        context->VertexBuffer[vnum].bz += (W3D_Float)context->ZOffset;

    pointer = (UBYTE*)context->WBuffer + vnum * context->ArrayPointer.texcoordstride;
    wa = (float*)pointer;
    *wa = w;
}



//avoid double projections:

#ifdef __VBCC__

#define A_ToV(ctx, e) {\
MGLVertex *v = &ctx->VertexBuffer[e];\
v->v.x = v->bx;\
v->v.y = v->by;\
v->v.z = v->bz;\
v->v.w = 1.0 / v->bw; \
}

#define V_ToScreen(ctx,vnum){\
static float wdiv;\
wdiv = 1.0 / ctx->VertexBuffer[vnum].bw; \
ctx->VertexBuffer[vnum].v.x = ctx->ax + ctx->VertexBuffer[vnum].bx * wdiv * ctx->sx; \
ctx->VertexBuffer[vnum].v.y = ctx->ay - ctx->VertexBuffer[vnum].by * wdiv * ctx->sy; \
ctx->VertexBuffer[vnum].v.z = ctx->az + ctx->VertexBuffer[vnum].bz * wdiv * ctx->sz; \
if (ctx->ZOffset_State == GL_TRUE) ctx->VertexBuffer[vnum].v.z += (W3D_Float)ctx->ZOffset; \
ctx->VertexBuffer[vnum].v.w = wdiv; \
}

#else

static INLINE void A_ToV(GLcontext context, int e)
{
    context->VertexBuffer[e].v.x = (W3D_Float)context->VertexBuffer[e].bx;
    context->VertexBuffer[e].v.y = (W3D_Float)context->VertexBuffer[e].by;
    context->VertexBuffer[e].v.z = (W3D_Float)context->VertexBuffer[e].bz;
    context->VertexBuffer[e].v.w = (W3D_Float)(1.0 / context->VertexBuffer[e].bw);
}

static INLINE void V_ToScreen(GLcontext context, int vnum)
{
    GLfloat wdiv = 1.f / context->VertexBuffer[vnum].bw;

    context->VertexBuffer[vnum].v.x = (W3D_Float)(context->ax + context->VertexBuffer[vnum].bx * wdiv * context->sx);

    context->VertexBuffer[vnum].v.y = (W3D_Float)(context->ay - context->VertexBuffer[vnum].by * wdiv * context->sy);

    context->VertexBuffer[vnum].v.z = (W3D_Float)(context->az + context->VertexBuffer[vnum].bz * wdiv * context->sz);

    if (context->ZOffset_State == GL_TRUE) context->VertexBuffer[vnum].v.z += (W3D_Float)context->ZOffset; \

    context->VertexBuffer[vnum].v.w = (W3D_Float)wdiv; \
}

#endif


void A_DrawPoints(GLcontext context, const int first, const int count)
{
}


void A_DrawLines(GLcontext context, const int first, const int count)
{
}


void A_DrawLineStrip(GLcontext context, const int first, const int count)
{
}


void A_DrawLineLoop(GLcontext context, const int first, const int count)
{
}


void A_DrawQuads(GLcontext context, const int first, const int count)
{
}


void A_DrawQuadStrip(GLcontext context, const int first, const int count)
{
}


void A_DrawTriFan(GLcontext context, const int first, const int count)
{
      int i,j;
    int size;
    int outcode;
      ULONG local_or, local_and;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;
      static ULONG    complete[MGL_MAXVERTS];
      static GLboolean visible[MGL_MAXVERTS];
      int triangle;
      static PolyBuffer polys[64];
      PolyBuffer clip[64];
      int pnum, cnum, backface, prevcopy, free;
      int sign;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
    //compiled arrays

       size = count;

       //first check if we are in guardband-mode
       //and discard/shrink offscreen primitives

       if(Clip_Volume_Bypass == GL_TRUE + 1)
       {
        i = first + size - 2;

        do
        {
            local_and = context->VertexBuffer[first].outcode & context->VertexBuffer[i].outcode & context->VertexBuffer[i+1].outcode;

            if(local_and == 0)
                break;

        size--;
        i--;
        } while (i > first);

        if(size < 3)
            return;
       }

       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, size);
       }
       else
       {
       int newfirst;
       float fsign;
       float area;
       float x1,x2;
       float y1,y2;

       #define x(a) (context->VertexBuffer[first+a].bx)
       #define y(a) (context->VertexBuffer[first+a].by)

        fsign = (float)-context->CurrentCullSign;

        backface = 0;
        newfirst = 0;

              if(size == 3)
            {
                  x1 = x(1) - x(0);
                  y1 = y(1) - y(0);
                  x2 = x(2) - x(0);
                  y2 = y(2) - y(0);

                  area = y2*x1 - x2*y1;
                  area *= fsign;
        }
        else
        {
            float x0,y0;
            float area2;

                  x0 = x(0);
                  y0 = y(0);

                  x1 = x(1) - x0;
                  y1 = y(1) - y0;
                  x2 = x(2) - x0;
                    y2 = y(2) - y0;

                    area = y2*x1 - x2*y1;
              area *= fsign;

                       if(area < 0.f)
                       {
                            newfirst++;
                            area = 0.f;
                       }

                       i = 1;
                       do
                       {
                         x1 = x2;
                           y1 = y2;
                           x2 = x(i+2) - x0;
                           y2 = y(i+2) - y0;

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                              if(area2 < 0.f)
                              {
                  if(newfirst == i)
                    newfirst++;
                  else
                                      backface++;
                            }
                            else
                              {
                                backface = 0;
                                area += area2;
                              }

                    i++;
                    } while (i < size-2);
        }

        if(area < context->MinTriArea)
        return;

        size -= backface; //cut end

        if( newfirst )
        {

            size -= newfirst;
            newfirst += first;

            e_wrap[newfirst] = first;

            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)&(e_wrap[newfirst]));

            e_wrap[newfirst] = newfirst;
        }
        else
        {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, size);
        }
       #undef x
       #undef y
       }
    return;
    }

    sign = context->CurrentCullSign;

    outcode = A_TransformArray(context, first, count);


      if(outcode < 0)
      {
        return;
      }

      if (outcode == 0)
      {
        size = count;

        A_ToScreenArray(context, first, count);

        if(context->CullFace_State == GL_TRUE)
        {
        int newfirst;
        float fsign;
        float area;
        float x1,x2;
        float y1,y2;

        #define x(a) (context->VertexBuffer[first+a].bx)
        #define y(a) (context->VertexBuffer[first+a].by)

        fsign = (float)-sign;

        backface = 0;
        newfirst = 0;


                    if(size == 3)
                  {
                        x1 = x(1) - x(0);
                        y1 = y(1) - y(0);
                        x2 = x(2) - x(0);
                        y2 = y(2) - y(0);

                        area = y2*x1 - x2*y1;
                        area *= fsign;
              }
              else
              {
                  float x0,y0;
                  float area2;

                        x0 = x(0);
                        y0 = y(0);

                        x1 = x(1) - x0;
                        y1 = y(1) - y0;
                        x2 = x(2) - x0;
                        y2 = y(2) - y0;

                        area = y2*x1 - x2*y1;
                  area *= fsign;

                           if(area < 0.f)
                           {
                            newfirst++;
                            area = 0.f;
                           }

                           i = 1;
                           do
                           {
                         x1 = x2;
                           y1 = y2;
                           x2 = x(i+2) - x0;
                           y2 = y(i+2) - y0;

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                              if(area2 < 0.f)
                              {
                  if(newfirst == i)
                    newfirst++;
                  else
                                      backface++;
                            }
                            else
                              {
                                backface = 0;
                                area += area2;
                              }

                           i++;
                           } while (i < size-2);
            }

            if(area < context->MinTriArea)
            return;

            size -= backface; //cut end

            if( newfirst )
            {
                size -= newfirst;
                newfirst += first;

                e_wrap[newfirst] = first;

                error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)&(e_wrap[newfirst]));

                e_wrap[newfirst] = newfirst;

                return;
            }

        #undef x
        #undef y
        }

        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, size);

      return;
      }


        if (verts == NULL)
        {
                verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                if (!verts) return;
        }

      if(context->ArrayPointer.FixpointTrans == GL_TRUE)
      {
        ConvertFixverts(context, first, count);
      }

        backface = 0;
        triangle = 0;
        i = first+1;

   if(context->CullFace_State == GL_FALSE)
   {
        do
        {
                local_and = context->VertexBuffer[first].outcode
                        & context->VertexBuffer[i].outcode
                        & context->VertexBuffer[i+1].outcode;

                local_or = context->VertexBuffer[first].outcode
                        | context->VertexBuffer[i].outcode
                        | context->VertexBuffer[i+1].outcode;


                if (local_and == 0) // if the local and code is zero, we're not
                {
                    complete[triangle] = local_or;
                      visible[triangle] = GL_TRUE;
            backface = 0;
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }
           i++;
           triangle++;
        } while (triangle < count - 2);
   }
   else
   {
        do
        {
                local_and = context->VertexBuffer[first].outcode
                        & context->VertexBuffer[i].outcode
                        & context->VertexBuffer[i+1].outcode;

                local_or = context->VertexBuffer[first].outcode
                        | context->VertexBuffer[i].outcode
                        | context->VertexBuffer[i+1].outcode;


                if (local_and == 0) // if the local and code is zero, we're not
                {
             complete[triangle] = local_or;

                   if(local_or & MGL_CLIP_NEGW)
                   {
                        visible[triangle] = GL_TRUE;
              backface = 0;
                   }
                   else
                   {
                        visible[triangle] = DecideFrontface(context, &(context->VertexBuffer[first]), &(context->VertexBuffer[i]), &(context->VertexBuffer[i+1]), sign);

                        if(!visible[triangle])
                            backface++;
              else
                  backface = 0;
                   }
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }
           i++;
           triangle++;
        } while (triangle < count - 2);
   }


        if(backface == triangle) //early out
        return;

      size = count - backface;
      context->VertexBufferPointer -= backface;

           Convert(context, first);

        prevcopy = 0;
        pnum = 0;
        cnum = 0;
        free = context->VertexBufferPointer;
        triangle = 0; i = first + 1;

        do
        {
                if (visible[triangle] == GL_FALSE) // case 3
                {
                        triangle ++;
                        i        ++;
                }
                else
                {
                        if (complete[triangle]) // case 1
                        {
                                clip[cnum].numverts = 3;
                                clip[cnum].verts[0] = first;
                                clip[cnum].verts[1] = i + 0;
                                clip[cnum].verts[2] = i + 1;

                                if(prevcopy != i)
                                Convert(context, i+0);

                                Convert(context, i+1);

                                prevcopy = i+1;

                           AE_ClipPoly(context, &clip[cnum], free, complete[triangle]);

                           if(clip[cnum].numverts)
                           {

                               free = clip[cnum].nextfree;
                               cnum++;
                           }

                           triangle++; i++;


                        }
                        else
                        {   // case 2 (the difficult part)
                                int k=3;
                                polys[pnum].verts[0] = first;
                                polys[pnum].verts[1] = i+0;
                                polys[pnum].verts[2] = i+1;

                                triangle++; i++;

                                while (complete[triangle]==0 && visible[triangle] && triangle < size - 2)
                                {
                                polys[pnum].verts[k] = i+1;

                                i++; k++; triangle++;
                                }
                        polys[pnum].numverts = k;
                        pnum++;
                        }
                }
        } while (triangle < size - 2);

//Project to screen and draw:

   //avoid some double-projections

   if(cnum)
   {
   for(i=0; i<size; i++)
    visible[first+i] = 0;

   //project clipped verts without index lookup

      for(i=context->VertexBufferPointer; i<free; i++)
    {
          V_ToScreen(context, i);
    }
   }

   if(pnum) //draw buffered unclipped trifans
   {
        PolyBuffer *p;

        p = &polys[0];
        i = p->verts[1];

        A_ToScreen(context, first);
        A_ToScreen(context, i);
        A_ToScreen(context, i+1);

        visible[first] = 1;
        visible[i] = 1;
        visible[i+1] = 1;

        if(p->numverts > 3)
        {
        int last = p->verts[p->numverts-1];
        i+=2;
                do
                {
                        A_ToScreen(context, i);
                        visible[i] = 1;
                i++;
                } while (i <= last);
        }

        if(p->verts[1] == (first+1))
        {
        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, p->numverts);
        }
        else
        {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_ULONG, p->numverts, (void*)p->verts);
        }

        j = 1;
        while (j < pnum)
        {
                p = &polys[j];
                i = p->verts[1];

                A_ToScreen(context, i);
                A_ToScreen(context, i+1);

                visible[i] = 1;
                visible[i+1] = 1;

                if(p->numverts > 3)
                {
                int last = p->verts[p->numverts-1];
                i+=2;

                   do
                   {
                        A_ToScreen(context, i);
                        visible[i] = 1;
                   i++;
                   } while (i <= last);
                }

        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_ULONG, p->numverts, (void*)p->verts);

        j++;
        }
   }

   if(cnum) //draw clipped triangles
   {
   int first = 0;

   fan.tex = context->w3dTexBuffer[context->CurrentBinding];
   fan.st_pattern = 0;

     j = 0;
     do
     {
          PolyBuffer *p = &clip[j];

          for (i=0; i<p->numverts; i++)
          {
                int vert = p->verts[i];

                if(vert < context->VertexBufferPointer)
                {
                   switch(visible[vert])
                   {
                        case 2:
                                break;
                        case 1:
                                A_ToV(context, vert);
                                visible[vert] = 2;
                                break;
                        default:
                                V_ToScreen(context, vert);
                                visible[vert] = 2;
                                break;
                   }
                }

          verts[i+first] = &(context->VertexBuffer[vert].v);
          }

          fan.vertexcount = p->numverts;
          fan.v = &verts[first];

          error = W3D_DrawTriFanV(context->w3dContext, &fan);

          first += p->numverts;

        j++;
      } while (j < cnum);
   }
}


void A_DrawTriStrip(GLcontext context, const int first, const int count)
{
      int i,j;
    int size;
    int outcode;
      ULONG local_or, local_and;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;
      static GLboolean visible[MGL_MAXVERTS];
      static ULONG    complete[MGL_MAXVERTS];
      int triangle;
      static PolyBuffer polys[64];
      PolyBuffer clip[64];
      int pnum, cnum, backface, free, prevcopy;
      int sign;

    if(Clip_Volume_Bypass != GL_FALSE)
    {
    //compiled arrays
    size = count;

       //first check if we are in guardband-mode
       //and discard/shrink offscreen primitives

       if(Clip_Volume_Bypass == GL_TRUE + 1)
       {
        i = first + size - 3;
        do
        {
            local_and = context->VertexBuffer[i].outcode & context->VertexBuffer[i+1].outcode & context->VertexBuffer[i+2].outcode;

            if(local_and == 0)
                break;

        size--;
        i--;
        } while (i >= first);

        if(size < 3)
            return;
       }

       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, first, size);
       }
       else
       {
       int newfirst;
       float fsign;
       float area;
       float x1,x2;
       float y1,y2;

       #define x(a) (context->VertexBuffer[first+a].bx)
       #define y(a) (context->VertexBuffer[first+a].by)

        fsign = (float)-context->CurrentCullSign;

        backface = 0;
        newfirst = 0;

                 if(size == 3)
            {
                     x1 = x(1) - x(0);
                     y1 = y(1) - y(0);
                     x2 = x(2) - x(0);
                     y2 = y(2) - y(0);

                     area = y2*x1 - x2*y1;
                     area *= fsign;
          }
          else
          {
              float a1,a2,b1,b2;
              float area2;

                     a1 = x(1);
                     b1 = y(1);
                     a2 = x(2);
                     b2 = y(2);

                     x1 = a1 - x(0);
                     y1 = b1 - y(0);
                     x2 = a2 - x(0);
                     y2 = b2 - y(0);

                     area = y2*x1 - x2*y1;
             area *= fsign;

                        if(area < 0.f)
                        {
                             newfirst++;
                             area = 0.f;
                        }

                        i = 1;
                        do
                    {
                           fsign = -fsign;
                           x1 = a2 - a1;
                           y1 = b2 - b1;
                           x2 = x(i+2) - a1;
                           y2 = y(i+2) - b1;
                           a1 = a2;
                          b1 = b2;
                           a2 = x(i+2);
                           b2 = y(i+2);

                           area2 = y2*x1 - x2*y1;
                area2 *= fsign;

                if(area2 < 0.f)
                {
                  if(newfirst == i)
                    newfirst++;
                  else
                                      backface++;
                }
                else
                 {
                                backface = 0;
                                area += area2;
                }

                     i++;
              } while (i < size-2);
        }

       if(area < context->MinTriArea)
        return;

       size -= newfirst + backface;
       newfirst += first;

       error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, newfirst, size);

       #undef x
       #undef y
       }
    return;
    }

    sign = context->CurrentCullSign;

    outcode = A_TransformArray(context, first, count);

      if (outcode < 0)
      {
        return;
      }

      if (outcode == 0)
      {
        int newfirst;
        size = count;

        A_ToScreenArray(context, first, count);

        if(context->CullFace_State == GL_FALSE)
        {
            newfirst = first;
        }
        else
        {
        #define x(a) (context->VertexBuffer[first+a].bx)
        #define y(a) (context->VertexBuffer[first+a].by)

        float fsign;
        float area;
        float x1,x2;
        float y1,y2;

        fsign = (float)-sign;

        backface = 0;
        newfirst = 0;


                    if(size == 3)
                  {
                        x1 = x(1) - x(0);
                        y1 = y(1) - y(0);
                        x2 = x(2) - x(0);
                        y2 = y(2) - y(0);

                        area = y2*x1 - x2*y1;
                        area *= fsign;
              }
              else
              {
                  float a1,a2,b1,b2;
                  float area2;

                        a1 = x(1);
                        b1 = y(1);
                        a2 = x(2);
                        b2 = y(2);

                        x1 = a1 - x(0);
                        y1 = b1 - y(0);
                        x2 = a2 - x(0);
                        y2 = b2 - y(0);

                        area = y2*x1 - x2*y1;
                  area *= fsign;

                           if(area < 0.f)
                           {
                            newfirst++;
                            area = 0.f;
                           }

                           i = 1;
                           do
                           {
                           fsign = -fsign;
                           x1 = a2 - a1;
                           y1 = b2 - b1;
                           x2 = x(i+2) - a1;
                           y2 = y(i+2) - b1;
                           a1 = a2;
                          b1 = b2;
                           a2 = x(i+2);
                           b2 = y(i+2);

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                              if(area2 < 0.f)
                              {
                  if(newfirst == i)
                    newfirst++;
                  else
                                      backface++;
                            }
                            else
                              {
                                backface = 0;
                                area += area2;
                              }

                           i++;
                           } while (i < size-2);
            }

        if(area < context->MinTriArea)
            return;

        size -= newfirst + backface;
        newfirst += first;

        #undef x
        #undef y
        }

           error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, newfirst, size);

      return;
      }

        if (verts == NULL)
        {
                verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                if (!verts) return;
        }

      if(context->ArrayPointer.FixpointTrans == GL_TRUE)
      {
        ConvertFixverts(context, first, count);
      }


        backface = 0;
        triangle = 0;
        i = first;

   if(context->CullFace_State == GL_FALSE)
   {
        do
        {
                local_and = context->VertexBuffer[i+0].outcode
                                  & context->VertexBuffer[i+1].outcode
                                  & context->VertexBuffer[i+2].outcode;

                local_or = context->VertexBuffer[i+0].outcode
                                 | context->VertexBuffer[i+1].outcode
                                 | context->VertexBuffer[i+2].outcode;

                if (local_and == 0)
                {
            complete[triangle] = local_or;
            visible[triangle] = GL_TRUE;
            backface = 0;
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }

           i++;
           triangle++;
        } while (triangle < count - 2);
   }
   else
   {
        do
        {
                local_and = context->VertexBuffer[i+0].outcode
                                  & context->VertexBuffer[i+1].outcode
                                  & context->VertexBuffer[i+2].outcode;

                local_or = context->VertexBuffer[i+0].outcode
                                 | context->VertexBuffer[i+1].outcode
                                 | context->VertexBuffer[i+2].outcode;

                if (local_and == 0)
                {
                complete[triangle] = local_or;

                   if(local_or & MGL_CLIP_NEGW)
                   {
                        visible[triangle] = GL_TRUE;
              backface = 0;
                   }
                   else
                   {
                        visible[triangle] = DecideFrontface(context, &(context->VertexBuffer[i+0]), &(context->VertexBuffer[i+1]), &(context->VertexBuffer[i+2]), sign);

                        if(!visible[triangle])
                            backface++;
              else
                  backface = 0;
                   }
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }

                sign = -sign; //reverse order

           i++;
           triangle++;
        } while (triangle < count - 2);
   }

    if(backface == triangle) //early out
    return;

    size = count - backface;
    context->VertexBufferPointer -= backface;

    prevcopy = -1;
      pnum = 0;
      cnum = 0;
      free = context->VertexBufferPointer;
      triangle = 0; i=first;

        do
        {
                if (visible[triangle] == GL_FALSE) // case 3
                {
                        triangle++; i++;
                }
                else
                {
                        if (complete[triangle]) // case 1
                        {
                                clip[cnum].numverts = 3;
                                clip[cnum].verts[0] = i + 0;
                                clip[cnum].verts[1] = i + 1;
                                clip[cnum].verts[2] = i + 2;

//this element is never shared with next triangle:
                                if(prevcopy == i+1)
                                {
                                   Convert(context, i+2);
                                }

                                else if(prevcopy == i)
                                {
                                   Convert(context, i+1);
                                   Convert(context, i+2);
                                }
                  else
                  {
                                   Convert(context, i+0);
                                   Convert(context, i+1);
                                   Convert(context, i+2);
                  }

//this element is never shared with previous triangle:

                                prevcopy = i+2;

                           AE_ClipPoly(context, &clip[cnum], free, complete[triangle]);

                           if(clip[cnum].numverts)
                           {
                           free = clip[cnum].nextfree;
                           cnum++;
                           }

                           triangle++; i++;

                        }
                        else
                        {   // case 2 (the difficult part)
                                int k=3;
                                polys[pnum].verts[0] = i+0;
                                //polys[pnum].verts[1] = i+1;
                                //polys[pnum].verts[2] = i+2;

                                triangle++; i++;

                                while (visible[triangle] && complete[triangle]==0 && triangle < size - 2 && k < 64)
                                {
                                //polys[pnum].verts[k] = i+2;

                                i++; k++; triangle++;
                                }
                        polys[pnum].numverts = k;
                        pnum++;
                        }
                }
        } while (triangle < size - 2);



//Project to screen and Draw:

   //avoid some double-projections

   if(cnum)
   {
   for(i=0; i < size; i++)
    visible[first+i] = 0;

   //project clipped verts without need for index lookup

      for(i=context->VertexBufferPointer; i<free; i++)
      {
          V_ToScreen(context, i);
      }
   }

   if(pnum) //draw buffered unclipped tristrips
   {
        PolyBuffer *p;

        p = &polys[0];
        i = p->verts[0];

        A_ToScreen(context, i);
        A_ToScreen(context, i+1);
        A_ToScreen(context, i+2);

        visible[i] = 1;
        visible[i+1] = 1;
        visible[i+2] = 1;

        if(p->numverts > 3)
        {
        int last = p->numverts + i;
        i+=3;

                do
                {
                        A_ToScreen(context, i);
                        visible[i] = 1;
                i++;
                } while (i < last);
        }

        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, p->verts[0], p->numverts);

        j = 1;
        while (j < pnum)
        {
        int prev_projected = p->verts[0] + p->numverts-1;

                p = &polys[j];
                i = p->verts[0];

                if (i != prev_projected)
                {
                        A_ToScreen(context, i);
                        visible[i] = 1;
                }

                A_ToScreen(context, i+1);
                A_ToScreen(context, i+2);

                visible[i+1] = 1;
                visible[i+2] = 1;

                if(p->numverts > 3)
                {
                int last = i + p->numverts;
                i+=3;

                   do
                   {
                        A_ToScreen(context, i);
                        visible[i] = 1;
                   i++;
                   } while (i < last);
                }

        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, p->verts[0], p->numverts);

        j++;
        }
   }

   if(cnum) //draw clipped triangles
   {
   int first = 0;

   fan.tex = context->w3dTexBuffer[context->CurrentBinding];
   fan.st_pattern = 0;

     j = 0;
     do
     {
          PolyBuffer *p = &clip[j];

          for (i=0; i<p->numverts; i++)
          {
                int vert = p->verts[i];

                if(vert < context->VertexBufferPointer)
                {
                   switch(visible[vert])
                   {
                        case 2:
                                break;
                        case 1:
                                A_ToV(context, vert);
                                visible[vert] = 2;
                                break;
                        default:
                                V_ToScreen(context, vert);
                                visible[vert] = 2;
                                break;
                   }
                }
          verts[i+first] = &(context->VertexBuffer[vert].v);
          }

          fan.vertexcount = p->numverts;
          fan.v = &verts[first];

          error = W3D_DrawTriFanV(context->w3dContext, &fan);

          first += p->numverts;

     j++;
     } while (j < cnum);
   }
}


void A_DrawTriangles(GLcontext context, const int first, const int count)
{
      int i,j;
    int outcode;
      static ULONG   complete;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static GLboolean visible;
      PolyBuffer clip[128]; //should be enough
      static int sign;
      int cnum, free, start;
    static int chainverts;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
    //compiled arrays

       if(context->CullFace_State == GL_FALSE)
       {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first, count);
       }
       else
       {
       int start;
       float area;
       float x1,y1;
       float x2,y2;

       #define x(i) (context->VertexBuffer[first+i].bx)
       #define y(i) (context->VertexBuffer[first+i].by)

        start = 0;
        chainverts = 0;
        sign = context->CurrentCullSign;

        for(i=0; i<count; i+=3)
        {
           if(Clip_Volume_Bypass == GL_TRUE + 1)
           {
            if(context->VertexBuffer[first+i].outcode & context->VertexBuffer[first+i+1].outcode & context->VertexBuffer[first+i+2].outcode)
            {
               if(chainverts)
               {
                error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first + start, chainverts);

                chainverts = 0;
               }

            continue;
            }
           }

            x1 = x(i+1) - x(i);
            y1 = y(i+1) - y(i);
            x2 = x(i+2) - x(i);
            y2 = y(i+2) - y(i);

            area = y2*x1 - x2*y1;

            if(sign > 0)
            area = -area;

            if(area < context->MinTriArea)
            {
               if(chainverts)
               {
                error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first + start, chainverts);

                chainverts = 0;
               }
            }
            else
            {
               if(chainverts == 0)
               {
                start = i;
               }

               chainverts += 3;
            }
        }

        if(chainverts) //draw remainder
        {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first + start, chainverts);
        }

       #undef x
       #undef y
       }
    return;
    }

    if(verts == NULL)
    {
        verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                 if (!verts) return;
    }

    sign = context->CurrentCullSign;
    chainverts = 0;
    cnum = 0;
    free = context->VertexBufferPointer;
    start = first;
    i = first;

    do
    {
       outcode = A_TransformArray(context, i, 3);

       if(outcode < 0)
       {
        if(chainverts)
        {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, start, chainverts);

        chainverts = 0;
        }

       i+=3;
       }
       else
       {
        complete = (ULONG)outcode;

          if(complete == 0)
        {
                 A_ToScreenArray(context, i, 3);

           if(context->CullFace_State == GL_FALSE)
           {
            visible = GL_TRUE;
           }
           else
           {
           #define x(a) (context->VertexBuffer[a].bx)
           #define y(a) (context->VertexBuffer[a].by)

            float area;
            float x1,x2,y1,y2;

            x1 = x(i+1) - x(i);
            y1 = y(i+1) - y(i);
            x2 = x(i+2) - x(i);
            y2 = y(i+2) - y(i);

            area = y2*x1 - x2*y1;

            if(sign > 0)
            area = -area;

            if(area < context->MinTriArea)
                visible = GL_FALSE;
            else
                visible = GL_TRUE;

           #undef x
           #undef y
           }

                 if(visible)
                 {
            if(chainverts == 0)
            {
                start = i;
                chainverts = 3;
            }
            else
            {
                chainverts += 3;
            }
           }
           else if (chainverts)
           {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, start, chainverts);

            chainverts = 0;
           }
       i+=3;
       }
       else
       {
           if(chainverts)
           {
            error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, start, chainverts);

                chainverts = 0;
           }


           if(context->ArrayPointer.FixpointTrans == GL_TRUE)
           {
            ConvertFixverts(context, i, 3);
           }

               if(context->CullFace_State == GL_FALSE || (complete & MGL_CLIP_NEGW))
               {
             visible = GL_TRUE;
                 }
               else
               {
            visible = DecideFrontface(context, &(context->VertexBuffer[i+0]), &(context->VertexBuffer[i+1]), &(context->VertexBuffer[i+2]), sign);
               }

               if(visible)
               {
                   Convert(context, i+0);
                   Convert(context, i+1);
                   Convert(context, i+2);

                   clip[cnum].numverts = 3;
                   clip[cnum].verts[0] = i+0;
                   clip[cnum].verts[1] = i+1;
                   clip[cnum].verts[2] = i+2;

                   AE_ClipPoly(context, &clip[cnum], free, complete);

                   if(clip[cnum].numverts)
                   {
             free = clip[cnum].nextfree;
             cnum++;
                   }
               }
        i+=3;
        }
       }
    } while (i < first + count);


    if(chainverts) //draw remainder of unclipped triangles
    {
        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, start, chainverts);
    }

      if (cnum)
    {
      static W3D_TrianglesV fan;
    static PolyBuffer *p;
    static int start;

    fan.st_pattern = 0;
    fan.tex = context->w3dTexBuffer[context->CurrentBinding];

    start = 0;
    i = 0;

        do
        {
           p = &clip[i];
           j = 0;

           while (j < p->numverts)
           {
            verts[start+j] = &(context->VertexBuffer[p->verts[j]].v);
            V_ToScreen(context, p->verts[j]);
           j++;
           }

           fan.v = &verts[start];
           fan.vertexcount = p->numverts;

           start += p->numverts;

           error = W3D_DrawTriFanV(context->w3dContext, &fan);

        i++;
        } while (i < cnum);
      }
}

#if 0
void A_DrawTriangle(GLcontext context, const int first)
{
    int i;
    int outcode;
    ULONG complete;
      ULONG error;
      static W3D_Vertex *verts[16];
      static W3D_TrianglesV fan;
      PolyBuffer clip;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first, 3);
       }
       else
       {
       float area;
       float x1,y1;
       float x2,y2;

       #define x(i) (context->VertexBuffer[first+i].bx)
       #define y(i) (context->VertexBuffer[first+i].by)

            x1 = x(1) - x(0);
            y1 = y(1) - y(0);
            x2 = x(2) - x(0);
            y2 = y(2) - y(0);

            area = y2*x1 - x2*y1;

            if(context->CurrentCullSign > 0)
                area = -area;

            if(area > context->MinTriArea)
            {
                error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first, 3);
            }
       #undef x
       #undef y
       }
    return;
    }

    outcode = A_TransformArray(context, first, 3);

    if(outcode < 0)
    {
        return;
    }
    else if (outcode == 0)
    {
       A_ToScreenArray(context, first, 3);

       if(context->CullFace_State == GL_TRUE)
       {
       float area;
       float x1,y1;
       float x2,y2;

       #define x(i) (context->VertexBuffer[first+i].bx)
       #define y(i) (context->VertexBuffer[first+i].by)

            x1 = x(1) - x(0);
            y1 = y(1) - y(0);
            x2 = x(2) - x(0);
            y2 = y(2) - y(0);

            area = y2*x1 - x2*y1;

            if(context->CurrentCullSign > 0)
                area = -area;

            if(area < context->MinTriArea)
                return;
       #undef x
       #undef y
       }

    error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, first, 3);

    return;
    }

    complete = (ULONG)outcode;

    if(context->CullFace_State == GL_TRUE && !(complete & MGL_CLIP_NEGW))
    {
        if(DecideFrontface(context, &(context->VertexBuffer[first]), &(context->VertexBuffer[first+1]), &(context->VertexBuffer[first+2]), context->CurrentCullSign) == GL_FALSE)
        return;
    }

    Convert(context, first);
    Convert(context, first+1);
    Convert(context, first+2);

    clip.numverts = 3;
    clip.verts[0] = first;
    clip.verts[1] = first+1;
    clip.verts[2] = first+2;

    AE_ClipPoly(context, &clip, context->VertexBufferPointer, complete);

    if(clip.numverts < 3)
        return;

    i = 0;
    do
    {
        verts[i] = &(context->VertexBuffer[clip.verts[i]].v);
        V_ToScreen(context, clip.verts[i]);
    i++;
    } while (i < clip.numverts);

    fan.st_pattern = 0;
    fan.tex = context->w3dTexBuffer[context->CurrentBinding];
    fan.v = verts;
    fan.vertexcount = clip.numverts;

    error = W3D_DrawTriFanV(context->w3dContext, &fan);
}
#endif

void A_DrawPolygon(GLcontext context, const int first, const int count)
{
    int i,j;
    int outcode;
    ULONG complete;
    ULONG error;
    GLboolean visible;
    PolyBuffer clip;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
    //compiled arrays

       if(Clip_Volume_Bypass == GL_TRUE + 1)
       {
        ULONG and_code;

        and_code = 0xff;

        for(i=first; i<first+count; i++)
            and_code &= context->VertexBuffer[i].outcode;

        if(and_code)
            return;

       }

       if(context->CullFace_State == GL_TRUE)
       {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[first+a].bx)
        #define y(a) (context->VertexBuffer[first+a].by)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < count-2 && fabs(area) < context->MinTriArea)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
       }

    error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, count);

    return;
    }

    outcode = A_TransformArray(context, first, count);

    if(outcode < 0)
        return;

    else if(outcode == 0)
    {
       A_ToScreenArray(context, first, count);

       if(context->CullFace_State == GL_TRUE)
       {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[first+a].bx)
        #define y(a) (context->VertexBuffer[first+a].by)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < count-2 && fabs(area) < context->MinTriArea)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
       }

    error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, count);
    }
    else
    {
    complete = (ULONG)outcode;

        if(verts == NULL)
        {
            verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                     if (!verts) return;
        }


            if(context->ArrayPointer.FixpointTrans == GL_TRUE)
            {
           ConvertFixverts(context, first, count);
            }

        i = first;
        j = 0;

        while (i < first + count)
        {
            Convert(context, i);
            clip.verts[j++] = i;
        i++;
        }

        clip.numverts = count;

        AE_ClipPoly(context, &clip, context->VertexBufferPointer, complete);

        if(clip.numverts < 3)
            return;

        i = 0;
        do
        {
            verts[i] = &(context->VertexBuffer[clip.verts[i]].v);

               V_ToScreen(context, clip.verts[i]);
        i++;
        } while (i < clip.numverts);


       if(context->CullFace_State == GL_TRUE)
       {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[clip.verts[a]].bx)
        #define y(a) (context->VertexBuffer[clip.verts[a]].by)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < clip.numverts-2 && fabs(area) < context->MinTriArea)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
       }

    fan.tex = context->w3dTexBuffer[context->CurrentBinding];
    fan.st_pattern = 0;
    fan.v = verts;
    fan.vertexcount = clip.numverts;

    error = W3D_DrawTriFanV(context->w3dContext, &fan);
    }
}


void A_DrawFlatFan(GLcontext context, const int first, const int count)
{
    int i;
    ULONG error;
     MGLVertex *v;

    int Vstride;
    UBYTE *Vpointer;
    int Wstride;
    UBYTE *Wpointer;
      float *W;

      Vstride = context->ArrayPointer.vertexstride;
      Wstride = context->ArrayPointer.texcoordstride;

    Wpointer = (UBYTE*)context->WBuffer + first * Wstride;
    Vpointer = context->ArrayPointer.verts + first * Vstride;

   v = &context->VertexBuffer[first];

   if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
      int *V;
    i = count;

    do
    {
         V = (int*)Vpointer;

         v->bx = (float)V[0];
         v->by = (float)V[1];
         v->bz = (float)V[2];

         if(context->ClientState & GLCS_TEXTURE)
         {
        W = (float*)Wpointer;
              *W = 1.0;
         }

    v++; Vpointer += Vstride; Wpointer += Wstride;
      } while (--i);
   }
   else
   {
      float *V;
    i = count;

    do
    {
         V = (float*)Vpointer;

         v->bx = V[0];
         v->by = V[1];
         v->bz = V[2];

         if(context->ClientState & GLCS_TEXTURE)
         {
        W = (float*)Wpointer;
              *W = 1.0;
         }

    v++; Vpointer += Vstride; Wpointer += Wstride;
      } while (--i);
   }

   error = W3D_DrawArray(context->w3dContext, W3D_PRIMITIVE_TRIFAN, first, count);
}

//end of pipeline

#ifdef VA_SANITY_CHECK

// Swap_TextureCoordPointers added 01-06-2002
// Thanks to Olivier Fabre for making me aware of possible
// memprot problems without such a safety-check.
// It will only be needed if glTexcoordPointer,
// GL_TEXTURE_COORD_ARRAY and GL_TEXTURE_2D state are not
// in "sync".

void Swap_TextureCoordPointers(GLcontext context, GLboolean enable)
{
    if(enable == GL_TRUE)
    {
        Set_W3D_TexCoordPointer(context->w3dContext, (void*)context->ArrayPointer.texcoords, context->ArrayPointer.texcoordstride, 0, sizeof(GLfloat), context->ArrayPointer.w_off, W3D_TEXCOORD_NORMALIZED);
    }
    else
    {
    // guaranteed valid spot as long as vertexbuffer
    // is big enough

        Set_W3D_TexCoordPointer(context->w3dContext, (void*)&context->VertexBuffer[0].v.u, sizeof(MGLVertex), 0, 4, -4, W3D_TEXCOORD_NORMALIZED);
    }
}

#else

    #define Swap_TextureCoordPointers(c,e) {}

#endif

void GLEnableClientState(GLcontext context, GLenum state)
{
        switch (state)
        {
                case GL_TEXTURE_COORD_ARRAY:
            context->ClientState |= GLCS_TEXTURE;
            Swap_TextureCoordPointers(context, GL_TRUE);
            break;

                case GL_COLOR_ARRAY:
                      context->ClientState |= GLCS_COLOR;
                      break;

                case GL_VERTEX_ARRAY:
                      context->ClientState |= GLCS_VERTEX;
                      break;

                default:
                        GLFlagError(context, 1, GL_INVALID_ENUM);
                break;
        }
}


void GLDisableClientState(GLcontext context, GLenum state)
{
        switch (state)
        {
                case GL_TEXTURE_COORD_ARRAY:
                        context->ClientState &= ~GLCS_TEXTURE;
              Swap_TextureCoordPointers(context, GL_FALSE);
                        break;

                case GL_COLOR_ARRAY:
                        context->ClientState &= ~GLCS_COLOR;
                        break;

                case GL_VERTEX_ARRAY:
                        context->ClientState &= ~GLCS_VERTEX;
                        break;

                default:
                        GLFlagError(context, 1, GL_INVALID_ENUM);
                        break;
        }

}

#if 0 //NYI

void GLInterleavedArrays(GLcontext context, GLenum format, GLsizei stride, const GLvoid *pointer)
{

   #define PTR context->ArrayPointer

   PTR.colorpointer = NULL;
   PTR.texcoordpointer = NULL;

   switch((int)format)
   {
    case GL_V2F:
        context->ClientState = GLCS_VERTEX;
        PTR.verts = (UBYTE *)pointer;
        if(stride == 0)
            PTR.vertexstride = 2*sizeof(GLfloat);
        else
            PTR.vertexstride = stride;
    break;
    case GL_V3F:
        context->ClientState = GLCS_VERTEX;
        PTR.verts = (UBYTE *)pointer;
        if(stride == 0)
            PTR.vertexstride = 3*sizeof(GLfloat);
        else
            PTR.vertexstride = stride;
    break;
    case GL_C4UB_V2F:
        context->ClientState = GLCS_VERTEX|GLCS_COLOR;
        PTR.colors = (UBYTE *)pointer;
        PTR.verts = ((UBYTE *)pointer + 4);
        PTR.colormode = W3D_COLOR_UBYTE | W3D_CMODE_RGBA;
        if(stride == 0)
        {
            PTR.vertexstride = PTR.colorstride = 2*sizeof(GLfloat) + 4*sizeof(GLubyte);
        }
        else
        {
            PTR.vertexstride = PTR.colorstride = stride;
        }
    break;
    case GL_C4UB_V3F:
        context->ClientState = GLCS_VERTEX|GLCS_COLOR;
        PTR.colors = (UBYTE *)pointer;
        PTR.verts = ((UBYTE *)pointer + 4);
        PTR.colormode = W3D_COLOR_UBYTE | W3D_CMODE_RGBA;
        if(stride == 0)
        {
            PTR.vertexstride = PTR.colorstride = 3*sizeof(GLfloat) + 4*sizeof(GLubyte);
        }
        else
        {
            PTR.vertexstride = PTR.colorstride = stride;
        }
    break;
    case GL_C3F_V3F:
        context->ClientState = GLCS_VERTEX|GLCS_COLOR;
        PTR.colors = (UBYTE *)pointer;
        PTR.verts = ((UBYTE *)pointer + 12);
        PTR.colormode = W3D_COLOR_FLOAT | W3D_CMODE_RGB;

        if(stride == 0)
        {
            PTR.vertexstride = PTR.colorstride = 6*sizeof(GLfloat);
        }
        else
        {
            PTR.vertexstride = PTR.colorstride = stride;
        }
    break;
    case GL_T2F_V3F:
        context->ClientState = GLCS_VERTEX|GLCS_TEXTURE;
        PTR.texcoords = (UBYTE *)pointer;
        PTR.verts = ((UBYTE *)pointer + 8);
        if(stride == 0)
        {
            PTR.vertexstride = PTR.texcoordstride = 5*sizeof(GLfloat);
        }
        else
        {
            PTR.vertexstride = PTR.texcoordstride = stride;
        }
    break;
    case GL_T2F_C4UB_V3F:
        context->ClientState = GLCS_VERTEX|GLCS_TEXTURE|GLCS_COLOR;
        PTR.texcoords = (UBYTE *)pointer;
        PTR.colors = ((UBYTE *)pointer + 8);
        PTR.verts = ((UBYTE *)pointer + 12);
        PTR.colormode = W3D_COLOR_UBYTE | W3D_CMODE_RGBA;
        if(stride == 0)
        {
            PTR.vertexstride = PTR.colorstride = PTR.texcoordstride = 5*sizeof(GLfloat) + 4*sizeof(GLubyte);
        }
        else
        {
            PTR.vertexstride = PTR.colorstride = PTR.texcoordstride = stride;
        }
    break;
    case GL_T2F_C3F_V3F:
        context->ClientState = GLCS_VERTEX|GLCS_TEXTURE|GLCS_COLOR;
        PTR.texcoords = (UBYTE *)pointer;
        PTR.colors = ((UBYTE *)pointer + 8);
        PTR.verts = ((UBYTE *)pointer + 20);
        PTR.colormode = W3D_COLOR_FLOAT | W3D_CMODE_RGB;
        if(stride == 0)
        {
            PTR.vertexstride = PTR.colorstride = PTR.texcoordstride = 8*sizeof(GLfloat);
        }
        else
        {
            PTR.vertexstride = PTR.colorstride = PTR.texcoordstride = stride;
        }
    break;
   }

   #undef PTR

}

#endif


static GLboolean cur_pipeline_state = GL_TRUE;

void GLTexCoordPointer(GLcontext context, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
   int w3dStride;
   int w_off;
   BYTE *base, *target;

//check pipeline state to make sure that w_off was calculated:

    if((context->VertexArrayPipeline == cur_pipeline_state) && (context->ArrayPointer.texcoords == (UBYTE*)pointer))
        return;


#ifdef VA_SANITY_CHECK

    if(!pointer) //thanks to OF for making me aware..
    {
    context->ArrayPointer.texcoords = (UBYTE*)&context->VertexBuffer[0].v.u;
    context->ArrayPointer.texcoordstride = sizeof(MGLVertex);
    context->ArrayPointer.w_off = -4;

      Set_W3D_TexCoordPointer(context->w3dContext, (void*)&context->VertexBuffer[0].v.u, sizeof(MGLVertex), 0, sizeof(GLfloat), -4, W3D_TEXCOORD_NORMALIZED);

    return;
    }

#endif

    if (stride == 0)    w3dStride = size*sizeof(GLfloat);
    else        w3dStride = stride;

    if (type != GL_FLOAT)   GLFlagError(context, 1, GL_INVALID_ENUM);

    context->ArrayPointer.texcoords = (UBYTE*)pointer;
    context->ArrayPointer.texcoordstride = w3dStride;

    cur_pipeline_state = context->VertexArrayPipeline;

    if(context->VertexArrayPipeline == GL_FALSE)
    {
        if (size != 4)          GLFlagError(context, 1, GL_INVALID_VALUE);

    Set_W3D_TexCoordPointer(context->w3dContext, (void*)context->ArrayPointer.texcoords, 4*sizeof(GLfloat), 0, sizeof(GLfloat), 3*sizeof(GLfloat), W3D_TEXCOORD_NORMALIZED);
    }
    else
    {
      //find w_array-offset relative to current pointer:

    target = (BYTE*)&context->WBuffer[0];
    base   = (BYTE*)pointer;

    if(target < base)
    {
        w_off = (base - target);
        w_off = -w_off;
    }
    else
    {
        w_off = (target - base);
    }

    context->ArrayPointer.w_off = w_off;

      Set_W3D_TexCoordPointer(context->w3dContext, (void*)context->ArrayPointer.texcoords, w3dStride, 0, sizeof(GLfloat), w_off, W3D_TEXCOORD_NORMALIZED);
   }
}


void GLColorPointer(GLcontext context, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
    int w3dStride;
    ULONG w3dType, w3dFormat;

    if(context->ArrayPointer.colors == (UBYTE*)pointer)
        return;

#ifdef VA_SANITY_CHECK

    if(!pointer) //thanks to OF for making me aware..
    {
    context->ArrayPointer.colors = (UBYTE*)&context->VertexBuffer[0].color[0];
      context->ArrayPointer.colorstride = sizeof(MGLVertex);
    context->ArrayPointer.colormode = W3D_COLOR_UBYTE | W3D_CMODE_RGBA;
      Convert = (Convfn)Convert_UB_RGBA;

      Set_W3D_ColorPointer(context->w3dContext, (void *)&context->VertexBuffer[0].color[0], sizeof(MGLVertex),
            W3D_COLOR_UBYTE, W3D_CMODE_RGBA, 0);

    return;
    }

#endif

    if (type != GL_UNSIGNED_BYTE && type != GL_FLOAT && type != MGL_UBYTE_BGRA && type != MGL_UBYTE_ARGB)
        GLFlagError(context, 1, GL_INVALID_ENUM);

    if (stride == 0)
        w3dStride = size * (type == GL_FLOAT ? sizeof(GLfloat) : sizeof(GLubyte));
    else
        w3dStride = stride;

    context->ArrayPointer.colors = (UBYTE*)pointer;
    context->ArrayPointer.colorstride = w3dStride;


    if(type == GL_FLOAT)
    w3dType = W3D_COLOR_FLOAT;
    else
    w3dType = W3D_COLOR_UBYTE;


    if (type != MGL_UBYTE_ARGB)
    {
      if(type == GL_FLOAT)
      {
        if(size == 3)
        {
           w3dFormat = W3D_CMODE_RGB;
             Convert   = (Convfn)Convert_F_RGB;
        }
        else
        {
           w3dFormat = W3D_CMODE_RGBA;
             Convert   = (Convfn)Convert_F_RGBA;
        }
      }
      else if (type == MGL_UBYTE_BGRA)
      {
        if(size == 3)
        {
           w3dFormat = W3D_CMODE_BGR;
           Convert   = (Convfn)Convert_UB_BGR;
        }
        else
        {
           w3dFormat = W3D_CMODE_BGRA;
           Convert   = (Convfn)Convert_UB_BGRA;
        }
      }
      else // GL_UNSIGNED_BYTE
      {
        if(size == 3)
        {
           w3dFormat = W3D_CMODE_RGB;
             Convert   = (Convfn)Convert_UB_RGB;
        }
        else
        {
           w3dFormat = W3D_CMODE_RGBA;
             Convert   = (Convfn)Convert_UB_RGBA;
        }
      }
    }
    else
    {
        w3dFormat = W3D_CMODE_ARGB;
        Convert   = (Convfn)Convert_UB_ARGB;
    }

    context->ArrayPointer.colormode = w3dType | w3dFormat;

    Set_W3D_ColorPointer(context->w3dContext, (void *)context->ArrayPointer.colors, w3dStride, w3dType, w3dFormat, 0);
}


void GLVertexPointer(GLcontext context, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
    int w3dStride;

    if (size < 3 || type != GL_FLOAT || type != GL_INT)
    GLFlagError(context, 1, GL_INVALID_VALUE);

    if(context->ArrayPointer.verts == (UBYTE*)pointer)
        return;

#ifdef VA_SANITY_CHECK

    if(!pointer) //thanks to OF for making me aware..
    {
    context->ArrayPointer.verts = (UBYTE*)&context->VertexBuffer[0].bx;
    context->ArrayPointer.vertexstride = sizeof(MGLVertex);


    if (Reset_W3D_VertexPointer == GL_TRUE)
    {
        Set_W3D_VertexPointer(context->w3dContext, (void *) &(context->VertexBuffer->bx), sizeof(MGLVertex), W3D_VERTEX_F_F_F, 0);
    Reset_W3D_VertexPointer = GL_FALSE;
    }

    return;
    }

#endif

    if(type == GL_INT)
    {
    context->ArrayPointer.FixpointTrans = GL_TRUE;
      if (stride == 0) w3dStride = size * sizeof(GLint);
    else w3dStride = stride;
    }
    else
    {
    context->ArrayPointer.FixpointTrans = GL_FALSE;
      if (stride == 0) w3dStride = size * sizeof(GLfloat);
    else w3dStride = stride;
    }

    context->ArrayPointer.verts = (UBYTE*)pointer;
    context->ArrayPointer.vertexstride = w3dStride;


    if(context->VertexArrayPipeline == GL_FALSE)
    {
    if(type == GL_INT)
      GLFlagError(context, 1, GL_INVALID_VALUE);

    Reset_W3D_VertexPointer = GL_TRUE; //not default

    Set_W3D_VertexPointer(context->w3dContext, (void *)pointer, w3dStride, W3D_VERTEX_F_F_F, 0);
    }
    else if (Reset_W3D_VertexPointer == GL_TRUE)
    {
    Set_W3D_VertexPointer(context->w3dContext, (void *) &(context->VertexBuffer->bx), sizeof(MGLVertex), W3D_VERTEX_F_F_F, 0);

    Reset_W3D_VertexPointer = GL_FALSE;
    }
}


static INLINE void PreDraw(GLcontext context)
{
   if (context->FogDirty && context->Fog_State)
   {
        fog_Set(context);
        context->FogDirty = GL_FALSE;
   }

   if (context->ShadeModel == GL_FLAT && context->UpdateCurrentColor == GL_TRUE)
   {
    context->UpdateCurrentColor = GL_FALSE;
    W3D_SetCurrentColor(context->w3dContext, &context->CurrentColor);
   }

#ifdef AUTOMATIC_LOCKING_ENABLE

   if (context->LockMode == MGL_LOCK_MANUAL)
        return;

   else if (context->LockMode == MGL_LOCK_AUTOMATIC) // Automatic: Lock per primitive
   {
        if (W3D_SUCCESS == W3D_LockHardware(context->w3dContext))
        {
                context->w3dLocked = GL_TRUE;
        }
        else
        {
                printf("Error during LockHardware\n");
        }
   }
   else // Smart: Lock timer based
   {
        if (context->w3dLocked == GL_FALSE)
        {
            if (W3D_SUCCESS != W3D_LockHardware(context->w3dContext))
            {
                return; // give up
            }
            context->w3dLocked = GL_TRUE;
            TMA_Start(&(context->LockTime));
        }
   }
#endif

}


static INLINE void PostDraw(GLcontext context)
{
    context->VertexBufferPointer = 0;

#ifdef AUTOMATIC_LOCKING_ENABLE

    if (context->LockMode == MGL_LOCK_SMART && TMA_Check(&(context->LockTime)) == GL_TRUE)
    {
        // Time to unlock
        W3D_UnLockHardware(context->w3dContext);
        context->w3dLocked = GL_FALSE;
    }
    else if (context->LockMode == MGL_LOCK_AUTOMATIC)
    {
                W3D_UnLockHardware(context->w3dContext);
                context->w3dLocked = GL_FALSE;
    }

#endif
}


void GLDrawArrays(GLcontext context, GLenum mode, const GLint first, const GLsizei count)
{
   ULONG error, prim;
   int k;

#ifdef VA_SANITY_CHECK
   GLboolean ShadeModel_bypass;
   GLboolean TexCoord_bypass;
#endif

   //11-04-02 - check for compiled arrays
   //sorry - no time to write proper handling for this.
   //Anyways, glDrawArrays is rarely used within a lock.

   if(context->ArrayPointer.transformed == GL_TRUE && Clip_Volume_Bypass == GL_FALSE)
   {
    GLDrawElements(context, mode, count, GL_UNSIGNED_SHORT, (void*)&(e_wrap[first]));
    return;
   }


#ifdef VA_SANITY_CHECK

   ShadeModel_bypass = GL_FALSE;

   //Thanks to OF for making me aware of this unlikely case

   if(!(context->ClientState & GLCS_COLOR) && context->ShadeModel == GL_SMOOTH)
   {
    W3D_SetState(context->w3dContext, W3D_GOURAUD, W3D_DISABLE);
    context->ShadeModel = GL_FLAT;
       ShadeModel_bypass = GL_TRUE;
   }

#endif

   PreDraw(context);

#ifdef VA_SANITY_CHECK

   TexCoord_bypass = GL_FALSE;

   if(context->Texture2D_State[0] == GL_FALSE || !(context->ClientState & GLCS_TEXTURE))
   {
      Set_W3D_Texture(context->w3dContext, 0, NULL);

    if(context->ClientState & GLCS_TEXTURE)
    {
       context->ClientState &= ~GLCS_TEXTURE;
       TexCoord_bypass = GL_TRUE;
    }
   }

#else

   if(context->Texture2D_State[0] == GL_FALSE)
   {
      Set_W3D_Texture(context->w3dContext, 0, NULL);
   }

#endif

   else
   {
        Set_W3D_Texture(context->w3dContext, 0, context->w3dTexBuffer[context->CurrentBinding]);
   }

   if(context->VertexArrayPipeline == GL_FALSE)
   {
    switch(mode)
    {
        case GL_POINTS:
        prim = W3D_PRIMITIVE_POINTS;
        break;
        case GL_LINE_STRIP:
        prim = W3D_PRIMITIVE_LINESTRIP;
        break;
        case GL_LINE_LOOP:
        prim = W3D_PRIMITIVE_LINELOOP;
        break;
        case GL_LINES:
        prim = W3D_PRIMITIVE_LINES;
        break;
        case GL_TRIANGLE_STRIP:
        prim = W3D_PRIMITIVE_TRISTRIP;
        break;
        case MGL_FLATFAN:
      case GL_POLYGON:
        case GL_TRIANGLE_FAN:
         prim = W3D_PRIMITIVE_TRIFAN;
        break;
        case GL_TRIANGLES:
        prim = W3D_PRIMITIVE_TRIANGLES;
        break;
        default:
            GLFlagError(context, 1, GL_INVALID_ENUM);
    }

    error = W3D_DrawArray(context->w3dContext, prim, first, count);

   }
   else
   {
    if(context->ArrayPointer.transformed == GL_TRUE)
    {
        context->VertexBufferPointer = context->ArrayPointer.lockfirst + context->ArrayPointer.locksize;
    }
    else
    {
        context->VertexBufferPointer = first + count;
    }
#if 0
    if((count == 3) && (mode != MGL_FLATFAN))
    {
        A_DrawTriangle(context, first);
    }
    else
#endif
    switch(mode)
    {
          case GL_TRIANGLE_STRIP:
          A_DrawTriStrip(context, first, count);
        break;

            case GL_TRIANGLE_FAN:
          A_DrawTriFan(context, first, count);
        break;

            case GL_TRIANGLES:
          A_DrawTriangles(context, first, count);
        break;

            case GL_POLYGON:
          A_DrawPolygon(context, first, count);
        break;

        case MGL_FLATFAN:
        A_DrawFlatFan(context, first, count);
           break;

            default:
           GLFlagError(context, 1, GL_INVALID_ENUM);
    }
   }

   PostDraw(context);

#ifdef VA_SANITY_CHECK

   if(ShadeModel_bypass == GL_TRUE)
   {
    W3D_SetState(context->w3dContext, W3D_GOURAUD, W3D_ENABLE);
    context->ShadeModel = GL_SMOOTH;
   }

   if(TexCoord_bypass == GL_TRUE)
   {
    context->ClientState |= GLCS_TEXTURE;
   }

#endif

}

#ifdef __VBCC__
#undef V_ToScreen
#undef A_ToV
#endif